package com.maiko.usercenter.lock;

import com.maiko.usercenter.common.ErrorCode;
import com.maiko.usercenter.exception.BusinessException;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

/**
 * @author: Maiko7
 * @create: 2025-07-14 17:15
 */
@Slf4j
@Component
public class LockExecutor {

    @Resource
    private RedissonClient redissonClient;

    /**
     * 执行带分布式锁的方法
     * @param lockKey 锁的 key
     * @param supplier 业务执行的 lambda
     * @param <T> 返回类型
     * @return 业务方法执行结果
     */
    public <T> T execute(String lockKey, Supplier<T> supplier) {
        RLock lock = redissonClient.getLock(lockKey);
        boolean locked = false;
        try {
            // 尝试加锁，最多等待5秒，锁自动释放时间10秒
            /**
             * 当前线程尝试获取锁；
             * 如果锁 被别人持有了，它会 最多等 5 秒；
             * 如果 5 秒内拿不到锁，它就会返回 false，说明获取失败；
             * 如果 成功拿到了锁，这个锁在 10 秒后会自动释放（即使你忘了解锁）；
             * locked = true 表示拿到锁，可以继续执行你的业务逻辑；
             * 最后在 finally 里判断 locked 是 true，才执行 unlock()。
             */
            log.info("尝试获取锁：{}", lockKey);
            locked = lock.tryLock(5, 10, TimeUnit.SECONDS);
            if (!locked) {
                log.warn("获取锁失败：{}", lockKey);
                throw new BusinessException(ErrorCode.OPERATION_ERROR, "系统繁忙，请稍后重试");
            }
            log.info("获取锁成功：{}", lockKey);
            return supplier.get();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new BusinessException(ErrorCode.SYSTEM_ERROR, "锁等待被中断");
        } finally {
            if (locked) {
                lock.unlock();
                log.info("释放锁：{}", lockKey);
            }
        }
    }
}
